import * as Cesium from 'cesium';
import { ModelManager } from './ModelManager.js';
import { CameraManager } from './CameraManager.js';
import { AppearanceManager } from './AppearanceManager.js';
import { Provider } from './Provider.js';
import { DataSourse } from './DataSourse.js';
import { Entity } from './Entity.js';
import { Primitive } from './Primitive.js';
import { CesiumManager } from '@/utils/CesiumManager';
export class SpatialVisualization {
  constructor(containerId) {
    this.containerId = containerId;
    this.cesiumManager = null;
    this.modelManager = null;
    this.cameraManager = null;
    this.appearanceManager = null;
    this.provider = null;
    this.dataSourse = null;
    this.entity = null;
    this.primitive = null;
    
    // 初始化所有组件
    this.init();
  }

  /**
   * 初始化空间可视化系统
   */
  init() {
    // 初始化Cesium管理器
    this.cesiumManager = new CesiumManager(this.containerId);
    this.cesiumManager.init();
    
    // 初始化各个功能模块
    this.modelManager = new ModelManager(this.cesiumManager);
    this.cameraManager = new CameraManager(this.cesiumManager);
    this.appearanceManager = new AppearanceManager(this.cesiumManager);
    this.provider = new Provider(this.cesiumManager);
    this.dataSourse = new DataSourse(this.cesiumManager);
    this.entity = new Entity(this.cesiumManager);
    this.primitive = new Primitive(this.cesiumManager);
  }

  /**
   * 运行综合演示案例
   */
  runDemo() {
    // 1. 添加地形和影像数据
    this.setupTerrainAndImagery();
    
    // 2. 添加3D模型
    this.addSampleModels();
    
    // 3. 创建空间数据可视化元素
    this.createSpatialDataVisualization();
    
    // 4. 添加粒子效果
    this.addParticleEffects();
    
    // 5. 设置相机路径和动画
    this.setupCameraAnimation();
    
    // 6. 应用场景美化
    this.applySceneEnhancements();
    
    // 7. 显示帧率
    this.showPerformanceInfo();
  }

  /**
   * 设置地形和影像数据
   */
  setupTerrainAndImagery() {
    // 添加地形提供者
    this.provider.addTerrainProvider('worldTerrain', {
      type: 'cesium-world',
      requestWaterMask: true,
      requestVertexNormals: true
    });
    
    // 设置当前地形提供者
    this.provider.setCurrentTerrainProvider('worldTerrain');
    
    // 添加影像提供者
    this.provider.addImageryProvider('openStreetMap', {
      type: 'open-street-map'
    });
  }

  /**
   * 添加示例3D模型
   */
  addSampleModels() {
    // 添加车辆模型
    this.modelManager.addModel('car1', 
      {longitude: 112.98, latitude: 28.19, height: 0}, 
      '/models/car.glb',
      {scale: 1.0}
    );
    
    // 添加卫星模型
    this.modelManager.addModel('satellite', 
      {longitude: 112.985, latitude: 28.195, height: 500}, 
      '/models/satellite.glb',
      {scale: 5.0}
    );
    
    // 批量添加建筑模型
    const buildings = [
      {
        id: 'building1',
        position: {longitude: 112.97, latitude: 28.18, height: 0},
        modelUrl: '/models/building.glb',
        options: {scale: 2.0}
      },
      {
        id: 'building2',
        position: {longitude: 112.975, latitude: 28.185, height: 0},
        modelUrl: '/models/building.glb',
        options: {scale: 1.5}
      }
    ];
    
    this.modelManager.addModels(buildings);
  }

  /**
   * 创建空间数据可视化元素
   */
  createSpatialDataVisualization() {
    // 创建点实体
    this.entity.createPoint('point1', 
      {longitude: 112.98, latitude: 28.19, height: 0},
      {
        pixelSize: 15,
        color: Cesium.Color.RED,
        outlineColor: Cesium.Color.BLACK,
        outlineWidth: 2
      }
    );
    
    // 创建折线实体
    this.entity.createPolyline('polyline1', [
      {longitude: 112.97, latitude: 28.18, height: 0},
      {longitude: 112.98, latitude: 28.19, height: 0},
      {longitude: 112.99, latitude: 28.20, height: 0}
    ], {
      width: 5,
      material: Cesium.Color.BLUE
    });
    
    // 创建多边形实体
    this.entity.createPolygon('polygon1', [
      {longitude: 112.97, latitude: 28.18, height: 0},
      {longitude: 112.99, latitude: 28.18, height: 0},
      {longitude: 112.99, latitude: 28.20, height: 0},
      {longitude: 112.97, latitude: 28.20, height: 0}
    ], {
      material: Cesium.Color.RED.withAlpha(0.5),
      outline: true,
      outlineColor: Cesium.Color.BLACK
    });
    
    // 创建圆形实体
    this.entity.createCircle('circle1',
      {longitude: 112.985, latitude: 28.195, height: 0},
      500,
      {
        material: Cesium.Color.GREEN.withAlpha(0.5),
        outline: true,
        outlineColor: Cesium.Color.BLACK
      }
    );
    
    // 创建城市白膜模型
    const buildings = [
      {
        id: 'whiteModel1',
        positions: [
          {longitude: 112.97, latitude: 28.18, height: 100},
          {longitude: 112.975, latitude: 28.18, height: 100},
          {longitude: 112.975, latitude: 28.185, height: 100},
          {longitude: 112.97, latitude: 28.185, height: 100}
        ]
      }
    ];
    
    this.appearanceManager.renderCityWhiteModel(buildings);
  }

  /**
   * 添加粒子效果
   */
  addParticleEffects() {
    // 创建下雨效果
    this.appearanceManager.createRainEffect('rain', {
      particleCount: 2000,
      speed: 30,
      size: 1,
      color: Cesium.Color.BLUE.withAlpha(0.7)
    });
    
    // 创建烟雾效果
    this.appearanceManager.createSmokeEffect('smoke',
      {longitude: 112.98, latitude: 28.19, height: 10},
      {
        color: Cesium.Color.GRAY.withAlpha(0.5),
        particleSize: 30
      }
    );
    
    // 创建火焰效果
    this.appearanceManager.createFireEffect('fire',
      {longitude: 112.985, latitude: 28.195, height: 0}
    );
  }

  /**
   * 设置相机动画
   */
  setupCameraAnimation() {
    // 创建相机路径
    const pathPositions = [
      {longitude: 112.97, latitude: 28.18, height: 1000},
      {longitude: 112.98, latitude: 28.19, height: 1000},
      {longitude: 112.99, latitude: 28.20, height: 1000}
    ];
    
    this.cameraManager.createCameraPath('demoPath', pathPositions);
  }

  /**
   * 应用场景美化
   */
  applySceneEnhancements() {
    this.appearanceManager.applySceneEnhancements({
      fog: {
        enabled: true,
        density: 0.0002
      },
      lighting: {
        enabled: true
      },
      atmosphere: {
        show: true
      },
      shadows: {
        enabled: true
      }
    });
  }

  /**
   * 显示性能信息
   */
  showPerformanceInfo() {
    this.appearanceManager.showFrameRate({
      position: 'top-right',
      style: {
        backgroundColor: 'rgba(0, 0, 0, 0.7)',
        color: 'white',
        padding: '5px',
        fontFamily: 'Arial, sans-serif',
        fontSize: '12px'
      }
    });
  }

  /**
   * 加载3D模型
   * @param {String} id - 模型ID
   * @param {Object} position - 模型位置 {longitude, latitude, height}
   * @param {String} modelUrl - 模型文件URL
   * @param {Object} options - 模型选项
   * @returns {Entity} 模型实体
   */
  addModel(id, position, modelUrl, options = {}) {
    return this.modelManager.addModel(id, position, modelUrl, options);
  }

  /**
   * 批量加载模型
   * @param {Array} modelConfigs - 模型配置数组
   * @returns {Array} 模型实体数组
   */
  addModels(modelConfigs) {
    return this.modelManager.addModels(modelConfigs);
  }

  /**
   * 创建模型集合
   * @param {String} collectionId - 集合ID
   * @param {Array} modelConfigs - 模型配置数组
   * @returns {Array} 模型实体数组
   */
  createModelCollection(collectionId, modelConfigs) {
    return this.modelManager.createModelCollection(collectionId, modelConfigs);
  }

  /**
   * 获取模型
   * @param {String} id - 模型ID
   * @returns {Entity} 模型实体
   */
  getModel(id) {
    return this.modelManager.getModel(id);
  }

  /**
   * 获取模型集合
   * @param {String} collectionId - 集合ID
   * @returns {Array} 模型实体数组
   */
  getModelCollection(collectionId) {
    return this.modelManager.getModelCollection(collectionId);
  }

  /**
   * 更新模型属性
   * @param {String} id - 模型ID
   * @param {Object} options - 更新选项
   */
  updateModel(id, options) {
    this.modelManager.updateModel(id, options);
  }

  /**
   * 设置模型可见性
   * @param {String} id - 模型ID
   * @param {Boolean} show - 是否显示
   */
  setModelVisibility(id, show) {
    this.modelManager.setModelVisibility(id, show);
  }

  /**
   * 批量设置模型可见性
   * @param {Array} ids - 模型ID数组
   * @param {Boolean} show - 是否显示
   */
  setModelsVisibility(ids, show) {
    this.modelManager.setModelsVisibility(ids, show);
  }

  /**
   * 设置模型集合可见性
   * @param {String} collectionId - 集合ID
   * @param {Boolean} show - 是否显示
   */
  setModelCollectionVisibility(collectionId, show) {
    this.modelManager.setModelCollectionVisibility(collectionId, show);
  }

  /**
   * 缩放模型
   * @param {String} id - 模型ID
   * @param {Number} scale - 缩放比例
   */
  scaleModel(id, scale) {
    this.modelManager.scaleModel(id, scale);
  }

  /**
   * 为模型添加动画效果
   * @param {String} id - 模型ID
   * @param {Object} animationOptions - 动画选项
   * @returns {Function} 停止动画的函数
   */
  animateModel(id, animationOptions = {}) {
    return this.modelManager.animateModel(id, animationOptions);
  }

  /**
   * 使模型面向相机
   * @param {String} id - 模型ID
   * @param {Boolean} enable - 是否启用
   */
  setModelBillboard(id, enable) {
    this.modelManager.setModelBillboard(id, enable);
  }

  /**
   * 高亮模型
   * @param {String} id - 模型ID
   * @param {Object} highlightOptions - 高亮选项
   */
  highlightModel(id, highlightOptions = {}) {
    this.modelManager.highlightModel(id, highlightOptions);
  }

  /**
   * 取消模型高亮
   * @param {String} id - 模型ID
   */
  unhighlightModel(id) {
    this.modelManager.unhighlightModel(id);
  }

  /**
   * 克隆模型
   * @param {String} originalId - 原始模型ID
   * @param {String} newId - 新模型ID
   * @param {Object} newPosition - 新位置 {longitude, latitude, height}
   * @returns {Entity} 新模型实体
   */
  cloneModel(originalId, newId, newPosition) {
    return this.modelManager.cloneModel(originalId, newId, newPosition);
  }

  /**
   * 计算模型边界框
   * @param {String} id - 模型ID
   * @returns {Object} 边界框信息
   */
  getModelBoundingSphere(id) {
    return this.modelManager.getModelBoundingSphere(id);
  }

  /**
   * 相机聚焦到模型
   * @param {String} id - 模型ID
   * @param {Object} options - 聚焦选项
   * @returns {Promise} 聚焦完成的Promise
   */
  focusOnModel(id, options = {}) {
    return this.modelManager.focusOnModel(id, options);
  }

  /**
   * 移除模型
   * @param {String} id - 模型ID
   */
  removeModel(id) {
    this.modelManager.removeModel(id);
  }

  /**
   * 移除模型集合
   * @param {String} collectionId - 集合ID
   */
  removeModelCollection(collectionId) {
    this.modelManager.removeModelCollection(collectionId);
  }

  /**
   * 清除所有模型
   */
  clearAllModels() {
    this.modelManager.clearAllModels();
  }

  /**
   * 获取所有模型
   * @returns {Map} 所有模型
   */
  getAllModels() {
    return this.modelManager.getAllModels();
  }

  /**
   * 获取模型数量
   * @returns {Number} 模型数量
   */
  getModelCount() {
    return this.modelManager.getModelCount();
  }

  /**
   * 飞行到指定位置
   * @param {Object} options - 飞行选项
   * @param {Object} options.destination - 目标位置 {longitude, latitude, height}
   * @param {Number} options.duration - 飞行持续时间(秒)
   * @param {Object} options.orientation - 相机方向 {heading, pitch, roll}
   * @returns {Promise} 飞行完成的Promise
   */
  flyTo(options) {
    return this.cameraManager.flyTo(options);
  }

  /**
   * 设置相机视角
   * @param {Object} options - 视角选项
   * @param {Object} options.position - 相机位置 {longitude, latitude, height}
   * @param {Object} options.orientation - 相机方向 {heading, pitch, roll}
   */
  setView(options) {
    this.cameraManager.setView(options);
  }

  /**
   * 相机看向指定目标
   * @param {Object} target - 目标位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   */
  lookAt(target, options = {}) {
    this.cameraManager.lookAt(target, options);
  }

  /**
   * 取消lookAt状态
   */
  cancelLookAt() {
    this.cameraManager.cancelLookAt();
  }

  /**
   * 创建相机路径
   * @param {String} name - 路径名称
   * @param {Array} positions - 位置数组 [{longitude, latitude, height}, ...]
   * @returns {Cesium.CameraPath} 相机路径对象
   */
  createCameraPath(name, positions) {
    return this.cameraManager.createCameraPath(name, positions);
  }

  /**
   * 沿路径飞行
   * @param {String} pathName - 路径名称
   * @param {Object} options - 飞行选项
   * @returns {Promise} 飞行完成的Promise
   */
  flyAlongPath(pathName, options = {}) {
    return this.cameraManager.flyAlongPath(pathName, options);
  }

  /**
   * 开始旋转相机
   * @param {Object} options - 旋转选项
   * @returns {Function} 停止旋转的函数
   */
  startRotating(options = {}) {
    return this.cameraManager.startRotating(options);
  }

  /**
   * 相机震动效果
   * @param {Object} options - 震动选项
   * @returns {Promise} 震动完成的Promise
   */
  shake(options = {}) {
    return this.cameraManager.shake(options);
  }

  /**
   * 保存当前相机状态
   * @param {String} name - 状态名称
   * @returns {Object} 相机状态
   */
  saveCameraState(name) {
    return this.cameraManager.saveCameraState(name);
  }

  /**
   * 恢复相机状态
   * @param {String|Object} nameOrState - 状态名称或状态对象
   */
  restoreCameraState(nameOrState) {
    this.cameraManager.restoreCameraState(nameOrState);
  }

  /**
   * 锁定相机到实体
   * @param {Entity} entity - 要锁定的实体
   */
  lockToEntity(entity) {
    this.cameraManager.lockToEntity(entity);
  }

  /**
   * 解锁相机
   */
  unlockCamera() {
    this.cameraManager.unlockCamera();
  }

  /**
   * 设置相机边界限制
   * @param {Object} rectangle - 限制矩形 {west, south, east, north}
   */
  setBoundaryLimit(rectangle) {
    this.cameraManager.setBoundaryLimit(rectangle);
  }

  /**
   * 重置相机限制
   */
  resetBoundaryLimit() {
    this.cameraManager.resetBoundaryLimit();
  }

  /**
   * 获取相机当前状态
   * @returns {Object} 相机状态信息
   */
  getCameraInfo() {
    return this.cameraManager.getCameraInfo();
  }

  /**
   * 创建自定义材质
   * @param {String} name - 材质名称
   * @param {Object} options - 材质选项
   * @returns {Material} 创建的材质
   */
  createCustomMaterial(name, options) {
    return this.appearanceManager.createCustomMaterial(name, options);
  }

  /**
   * 获取自定义材质
   * @param {String} name - 材质名称
   * @returns {Material|undefined} 材质对象
   */
  getCustomMaterial(name) {
    return this.appearanceManager.getCustomMaterial(name);
  }

  /**
   * 删除自定义材质
   * @param {String} name - 材质名称
   */
  removeCustomMaterial(name) {
    this.appearanceManager.removeCustomMaterial(name);
  }

  /**
   * 渲染城市白膜模型
   * @param {Array} buildings - 建筑物数据数组
   * @param {Object} options - 渲染选项
   * @returns {Array} 添加的实体数组
   */
  renderCityWhiteModel(buildings, options = {}) {
    return this.appearanceManager.renderCityWhiteModel(buildings, options);
  }

  /**
   * 更新建筑物样式
   * @param {String} buildingId - 建筑物ID
   * @param {Object} styleOptions - 样式选项
   */
  updateBuildingStyle(buildingId, styleOptions) {
    this.appearanceManager.updateBuildingStyle(buildingId, styleOptions);
  }

  /**
   * 高亮建筑物
   * @param {String} buildingId - 建筑物ID
   * @param {Object} highlightOptions - 高亮选项
   */
  highlightBuilding(buildingId, highlightOptions = {}) {
    this.appearanceManager.highlightBuilding(buildingId, highlightOptions);
  }

  /**
   * 取消高亮建筑物
   * @param {String} buildingId - 建筑物ID
   */
  unhighlightBuilding(buildingId) {
    this.appearanceManager.unhighlightBuilding(buildingId);
  }

  /**
   * 创建粒子特效系统
   * @param {String} id - 粒子系统ID
   * @param {Object} options - 粒子系统选项
   * @returns {ParticleSystem} 创建的粒子系统
   */
  createParticleSystem(id, options = {}) {
    return this.appearanceManager.createParticleSystem(id, options);
  }

  /**
   * 获取粒子系统
   * @param {String} id - 粒子系统ID
   * @returns {ParticleSystem|undefined} 粒子系统对象
   */
  getParticleSystem(id) {
    return this.appearanceManager.getParticleSystem(id);
  }

  /**
   * 更新粒子系统配置
   * @param {String} id - 粒子系统ID
   * @param {Object} options - 更新选项
   */
  updateParticleSystem(id, options) {
    this.appearanceManager.updateParticleSystem(id, options);
  }

  /**
   * 删除粒子系统
   * @param {String} id - 粒子系统ID
   */
  removeParticleSystem(id) {
    this.appearanceManager.removeParticleSystem(id);
  }

  /**
   * 创建烟花效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   * @returns {Array} 粒子系统数组
   */
  createFireworkEffect(id, position, options = {}) {
    return this.appearanceManager.createFireworkEffect(id, position, options);
  }

  /**
   * 触发烟花效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Number} count - 烟花数量
   * @param {Object} options - 选项
   */
  triggerFireworkEffect(id, position, count = 1, options = {}) {
    return this.appearanceManager.triggerFireworkEffect(id, position, count, options);
  }

  /**
   * 创建雨雪效果
   * @param {String} id - 效果ID
   * @param {String} type - 类型 'rain' 或 'snow'
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createWeatherEffect(id, type = 'rain', options = {}) {
    return this.appearanceManager.createWeatherEffect(id, type, options);
  }

  /**
   * 创建烟雾效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createSmokeEffect(id, position, options = {}) {
    return this.appearanceManager.createSmokeEffect(id, position, options);
  }

  /**
   * 创建下雨效果，以长沙市为中心
   * @param {String} id - 效果ID
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createRainEffect(id, options = {}) {
    return this.appearanceManager.createRainEffect(id, options);
  }

  /**
   * 创建火焰效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createFireEffect(id, position, options = {}) {
    return this.appearanceManager.createFireEffect(id, position, options);
  }

  /**
   * 创建爆炸效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createExplosionEffect(id, position, options = {}) {
    return this.appearanceManager.createExplosionEffect(id, position, options);
  }

  /**
   * 创建喷泉效果
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 选项
   * @returns {ParticleSystem} 粒子系统
   */
  createFountainEffect(id, position, options = {}) {
    return this.appearanceManager.createFountainEffect(id, position, options);
  }

  /**
   * 创建组合粒子效果（例如：烟雾+火焰）
   * @param {String} id - 效果ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Array} effects - 效果配置数组
   * @returns {Array} 粒子系统数组
   */
  createCombinedEffect(id, position, effects) {
    return this.appearanceManager.createCombinedEffect(id, position, effects);
  }

  /**
   * 启动粒子系统
   * @param {String} id - 粒子系统ID
   */
  startParticleSystem(id) {
    this.appearanceManager.startParticleSystem(id);
  }

  /**
   * 停止粒子系统
   * @param {String} id - 粒子系统ID
   */
  stopParticleSystem(id) {
    this.appearanceManager.stopParticleSystem(id);
  }

  /**
   * 暂停粒子系统
   * @param {String} id - 粒子系统ID
   */
  pauseParticleSystem(id) {
    this.appearanceManager.pauseParticleSystem(id);
  }

  /**
   * 恢复粒子系统
   * @param {String} id - 粒子系统ID
   * @param {Function} updateCallback - 更新回调函数
   */
  resumeParticleSystem(id, updateCallback) {
    this.appearanceManager.resumeParticleSystem(id, updateCallback);
  }

  /**
   * 显示帧率
   * @param {Object} options - 显示选项
   */
  showFrameRate(options = {}) {
    this.appearanceManager.showFrameRate(options);
  }

  /**
   * 隐藏帧率显示
   */
  hideFrameRate() {
    this.appearanceManager.hideFrameRate();
  }

  /**
   * 加载第三方插件
   * @param {String} pluginName - 插件名称
   * @param {Function} loader - 插件加载函数
   */
  loadThirdPartyPlugin(pluginName, loader) {
    return this.appearanceManager.loadThirdPartyPlugin(pluginName, loader);
  }

  /**
   * 获取已加载的第三方插件
   * @param {String} pluginName - 插件名称
   * @returns {Object|undefined} 插件对象
   */
  getThirdPartyPlugin(pluginName) {
    return this.appearanceManager.getThirdPartyPlugin(pluginName);
  }

  /**
   * 卸载第三方插件
   * @param {String} pluginName - 插件名称
   */
  unloadThirdPartyPlugin(pluginName) {
    this.appearanceManager.unloadThirdPartyPlugin(pluginName);
  }

  /**
   * 获取可用的第三方插件列表
   * @returns {Array} 插件名称数组
   */
  getAvailablePlugins() {
    return this.appearanceManager.getAvailablePlugins();
  }

  /**
   * 应用场景美化效果
   * @param {Object} options - 美化选项
   */
  applySceneEnhancements(options = {}) {
    this.appearanceManager.applySceneEnhancements(options);
  }

  /**
   * 添加地形提供者
   * @param {String} name - 地形提供者名称
   * @param {Object} options - 地形提供者选项
   * @returns {TerrainProvider} 创建的地形提供者
   */
  addTerrainProvider(name, options = {}) {
    return this.provider.addTerrainProvider(name, options);
  }

  /**
   * 获取地形提供者
   * @param {String} name - 地形提供者名称
   * @returns {TerrainProvider|undefined} 地形提供者对象
   */
  getTerrainProvider(name) {
    return this.provider.getTerrainProvider(name);
  }

  /**
   * 设置当前地形提供者
   * @param {String|TerrainProvider} nameOrProvider - 地形提供者名称或实例
   */
  setCurrentTerrainProvider(nameOrProvider) {
    this.provider.setCurrentTerrainProvider(nameOrProvider);
  }

  /**
   * 移除地形提供者
   * @param {String} name - 地形提供者名称
   */
  removeTerrainProvider(name) {
    this.provider.removeTerrainProvider(name);
  }

  /**
   * 添加影像提供者
   * @param {String} name - 影像提供者名称
   * @param {Object} options - 影像提供者选项
   * @returns {ImageryLayer} 创建的影像图层
   */
  addImageryProvider(name, options = {}) {
    return this.provider.addImageryProvider(name, options);
  }

  /**
   * 获取影像提供者
   * @param {String} name - 影像提供者名称
   * @returns {Object|undefined} 影像提供者和图层对象
   */
  getImageryProvider(name) {
    return this.provider.getImageryProvider(name);
  }

  /**
   * 更新影像图层属性
   * @param {String} name - 影像提供者名称
   * @param {Object} options - 要更新的属性
   */
  updateImageryLayer(name, options) {
    this.provider.updateImageryLayer(name, options);
  }

  /**
   * 移除影像提供者
   * @param {String} name - 影像提供者名称
   */
  removeImageryProvider(name) {
    this.provider.removeImageryProvider(name);
  }

  /**
   * 调整影像图层顺序
   * @param {String} name - 影像提供者名称
   * @param {Number} newIndex - 新的图层索引
   */
  reorderImageryLayer(name, newIndex) {
    this.provider.reorderImageryLayer(name, newIndex);
  }

  /**
   * 获取所有影像图层
   * @returns {Array} 所有影像图层数组
   */
  getAllImageryLayers() {
    return this.provider.getAllImageryLayers();
  }

  /**
   * 清除所有影像图层
   */
  clearAllImageryLayers() {
    this.provider.clearAllImageryLayers();
  }

  /**
   * 加载GeoJSON数据
   * @param {String} name - 数据源名称
   * @param {String|Object} data - GeoJSON数据或URL
   * @param {Object} options - 加载选项
   * @returns {Promise<DataSource>} 返回加载的数据源
   */
  async loadGeoJson(name, data, options = {}) {
    return await this.dataSourse.loadGeoJson(name, data, options);
  }

  /**
   * 加载KML数据
   * @param {String} name - 数据源名称
   * @param {String|Document} data - KML数据或URL
   * @param {Object} options - 加载选项
   * @returns {Promise<DataSource>} 返回加载的数据源
   */
  async loadKml(name, data, options = {}) {
    return await this.dataSourse.loadKml(name, data, options);
  }

  /**
   * 加载CZML数据
   * @param {String} name - 数据源名称
   * @param {String|Array|Document} data - CZML数据或URL
   * @param {Object} options - 加载选项
   * @returns {Promise<DataSource>} 返回加载的数据源
   */
  async loadCzml(name, data, options = {}) {
    return await this.dataSourse.loadCzml(name, data, options);
  }

  /**
   * 加载GPX数据
   * @param {String} name - 数据源名称
   * @param {String|Document} data - GPX数据或URL
   * @param {Object} options - 加载选项
   * @returns {Promise<DataSource>} 返回加载的数据源
   */
  async loadGpx(name, data, options = {}) {
    return await this.dataSourse.loadGpx(name, data, options);
  }

  /**
   * 获取数据源
   * @param {String} name - 数据源名称
   * @returns {DataSource|undefined} 数据源对象
   */
  getDataSource(name) {
    return this.dataSourse.getDataSource(name);
  }

  /**
   * 移除数据源
   * @param {String} name - 数据源名称
   */
  async removeDataSource(name) {
    await this.dataSourse.removeDataSource(name);
  }

  /**
   * 更新数据源选项
   * @param {String} name - 数据源名称
   * @param {Object} options - 更新选项
   */
  updateDataSource(name, options) {
    this.dataSourse.updateDataSource(name, options);
  }

  /**
   * 获取所有数据源
   * @returns {Array} 所有数据源数组
   */
  getAllDataSources() {
    return this.dataSourse.getAllDataSources();
  }

  /**
   * 清除所有数据源
   */
  async clearAllDataSources() {
    await this.dataSourse.clearAllDataSources();
  }

  /**
   * 查询数据源中的实体
   * @param {String} dataSourceName - 数据源名称
   * @param {Function} filter - 过滤函数
   * @returns {Array} 符合条件的实体数组
   */
  queryEntities(dataSourceName, filter) {
    return this.dataSourse.queryEntities(dataSourceName, filter);
  }

  /**
   * 高亮指定实体
   * @param {Entity} entity - 要高亮的实体
   * @param {Object} highlightOptions - 高亮选项
   */
  highlightEntity(entity, highlightOptions = {}) {
    this.dataSourse.highlightEntity(entity, highlightOptions);
  }

  /**
   * 取消高亮实体
   * @param {Entity} entity - 要取消高亮的实体
   */
  unhighlightEntity(entity) {
    this.dataSourse.unhighlightEntity(entity);
  }

  /**
   * 创建点实体
   * @param {String} id - 实体ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {Object} options - 点选项
   * @returns {Entity} 创建的实体
   */
  createPoint(id, position, options = {}) {
    return this.entity.createPoint(id, position, options);
  }

  /**
   * 创建折线实体
   * @param {String} id - 实体ID
   * @param {Array} positions - 位置数组 [{longitude, latitude, height}, ...]
   * @param {Object} options - 折线选项
   * @returns {Entity} 创建的实体
   */
  createPolyline(id, positions, options = {}) {
    return this.entity.createPolyline(id, positions, options);
  }

  /**
   * 创建多边形实体
   * @param {String} id - 实体ID
   * @param {Array} positions - 顶点位置数组 [{longitude, latitude, height}, ...]
   * @param {Object} options - 多边形选项
   * @returns {Entity} 创建的实体
   */
  createPolygon(id, positions, options = {}) {
    return this.entity.createPolygon(id, positions, options);
  }

  /**
   * 创建圆形实体
   * @param {String} id - 实体ID
   * @param {Object} center - 圆心位置 {longitude, latitude, height}
   * @param {Number} radius - 半径（米）
   * @param {Object} options - 圆形选项
   * @returns {Entity} 创建的实体
   */
  createCircle(id, center, radius, options = {}) {
    return this.entity.createCircle(id, center, radius, options);
  }

  /**
   * 创建椭圆实体
   * @param {String} id - 实体ID
   * @param {Object} center - 中心位置 {longitude, latitude, height}
   * @param {Number} semiMajorAxis - 长半轴
   * @param {Number} semiMinorAxis - 短半轴
   * @param {Object} options - 椭圆选项
   * @returns {Entity} 创建的实体
   */
  createEllipse(id, center, semiMajorAxis, semiMinorAxis, options = {}) {
    return this.entity.createEllipse(id, center, semiMajorAxis, semiMinorAxis, options);
  }

  /**
   * 创建矩形实体
   * @param {String} id - 实体ID
   * @param {Object} coordinates - 矩形坐标 {west, south, east, north}
   * @param {Object} options - 矩形选项
   * @returns {Entity} 创建的实体
   */
  createRectangle(id, coordinates, options = {}) {
    return this.entity.createRectangle(id, coordinates, options);
  }

  /**
   * 创建墙体实体
   * @param {String} id - 实体ID
   * @param {Array} positions - 墙体位置数组 [{longitude, latitude, height}, ...]
   * @param {Object} options - 墙体选项
   * @returns {Entity} 创建的实体
   */
  createWall(id, positions, options = {}) {
    return this.entity.createWall(id, positions, options);
  }

  /**
   * 创建模型实体
   * @param {String} id - 实体ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {String} modelUrl - 模型URL
   * @param {Object} options - 模型选项
   * @returns {Entity} 创建的实体
   */
  createModel(id, position, modelUrl, options = {}) {
    return this.entity.createModel(id, position, modelUrl, options);
  }

  /**
   * 创建标签实体
   * @param {String} id - 实体ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {String} text - 标签文本
   * @param {Object} options - 标签选项
   * @returns {Entity} 创建的实体
   */
  createLabel(id, position, text, options = {}) {
    return this.entity.createLabel(id, position, text, options);
  }

  /**
   * 创建布告板实体
   * @param {String} id - 实体ID
   * @param {Object} position - 位置 {longitude, latitude, height}
   * @param {String} image - 图像URL
   * @param {Object} options - 布告板选项
   * @returns {Entity} 创建的实体
   */
  createBillboard(id, position, image, options = {}) {
    return this.entity.createBillboard(id, position, image, options);
  }

  /**
   * 更新实体属性
   * @param {String} id - 实体ID
   * @param {Object} options - 更新选项
   */
  updateEntity(id, options) {
    this.entity.updateEntity(id, options);
  }

  /**
   * 删除实体
   * @param {String} id - 实体ID
   */
  removeEntity(id) {
    this.entity.removeEntity(id);
  }

  /**
   * 获取实体
   * @param {String} id - 实体ID
   * @returns {Entity} 实体对象
   */
  getEntity(id) {
    return this.entity.getEntity(id);
  }

  /**
   * 获取所有实体
   * @returns {EntityCollection} 实体集合
   */
  getAllEntities() {
    return this.entity.getAllEntities();
  }

  /**
   * 清除所有实体
   */
  clearAllEntities() {
    this.entity.clearAllEntities();
  }

  /**
   * 添加Primitive到场景中
   * @param {Object} primitiveOptions - Primitive配置选项
   * @param {String} id - Primitive的唯一标识符
   * @returns {Primitive} 添加的Primitive对象
   */
  addPrimitive(primitiveOptions, id) {
    return this.primitive.add(primitiveOptions, id);
  }

  /**
   * 创建点图元（高性能大量点渲染）
   * @param {Array} positions - 点位置数组
   * @param {Object} options - 点选项
   * @param {String} id - 图元ID
   * @returns {Primitive} 点图元
   */
  createPointPrimitive(positions, options = {}, id) {
    return this.primitive.createPointPrimitive(positions, options, id);
  }

  /**
   * 创建线图元（高性能大量线渲染）
   * @param {Array} polylines - 线条数组，每个包含positions属性
   * @param {Object} options - 线选项
   * @param {String} id - 图元ID
   * @returns {Primitive} 线图元
   */
  createPolylinePrimitive(polylines, options = {}, id) {
    return this.primitive.createPolylinePrimitive(polylines, options, id);
  }

  /**
   * 创建多边形图元（高性能大量多边形渲染）
   * @param {Array} polygons - 多边形数组，每个包含positions属性
   * @param {Object} options - 多边形选项
   * @param {String} id - 图元ID
   * @returns {Primitive} 多边形图元
   */
  createPolygonPrimitive(polygons, options = {}, id) {
    return this.primitive.createPolygonPrimitive(polygons, options, id);
  }

  /**
   * 创建批量图元（用于高性能渲染大量相同或相似的图元）
   * @param {Array} instances - 几何实例数组
   * @param {Object} appearance - 外观配置
   * @param {String} type - 图元类型
   * @param {String} id - 图元ID
   * @returns {Primitive} 批量图元
   */
  createBatchPrimitive(instances, appearance, type, id) {
    return this.primitive.createBatchPrimitive(instances, appearance, type, id);
  }

  /**
   * 创建组合图元（将多个图元组合为一个图元以提高性能）
   * @param {Array} primitives - 图元配置数组
   * @param {String} id - 组合图元ID
   * @returns {Primitive} 组合图元
   */
  createCompositePrimitive(primitives, id) {
    return this.primitive.createCompositePrimitive(primitives, id);
  }

  /**
   * 根据类型获取图元
   * @param {String} type - 图元类型
   * @returns {Array} 图元数组
   */
  getPrimitivesByType(type) {
    return this.primitive.getByType(type);
  }

  /**
   * 批量显示或隐藏指定类型的图元
   * @param {String} type - 图元类型
   * @param {Boolean} show - 是否显示
   */
  setShowPrimitivesByType(type, show) {
    this.primitive.setShowByType(type, show);
  }

  /**
   * 优化大量图元渲染性能
   * @param {String} type - 图元类型
   * @param {Object} options - 优化选项
   */
  optimizePrimitivesPerformance(type, options = {}) {
    this.primitive.optimizePerformance(type, options);
  }

  /**
   * 应用视锥剔除优化
   * @param {String} idOrPrimitive - 图元ID或图元对象
   */
  applyFrustumCulling(idOrPrimitive) {
    this.primitive.applyFrustumCulling(idOrPrimitive);
  }

  /**
   * 应用视距优化
   * @param {String} idOrPrimitive - 图元ID或图元对象
   * @param {Object} options - 视距选项
   */
  applyDistanceDisplayCondition(idOrPrimitive, options = {}) {
    this.primitive.applyDistanceDisplayCondition(idOrPrimitive, options);
  }

  /**
   * 从场景中移除Primitive
   * @param {String|Primitive} idOrPrimitive - Primitive的ID或Primitive对象本身
   * @returns {Boolean} 是否成功移除
   */
  removePrimitive(idOrPrimitive) {
    return this.primitive.remove(idOrPrimitive);
  }

  /**
   * 根据ID获取Primitive
   * @param {String} id - Primitive的ID
   * @returns {Primitive|undefined} Primitive对象或undefined
   */
  getPrimitiveById(id) {
    return this.primitive.getById(id);
  }

  /**
   * 获取所有Primitive对象
   * @returns {Array} Primitive对象数组
   */
  getAllPrimitives() {
    return this.primitive.getAll();
  }

  /**
   * 根据条件筛选Primitive
   * @param {Function} predicate - 筛选条件函数
   * @returns {Array} 符合条件的Primitive数组
   */
  filterPrimitives(predicate) {
    return this.primitive.filter(predicate);
  }

  /**
   * 清空所有Primitive
   */
  clearAllPrimitives() {
    this.primitive.clear();
  }

  /**
   * 获取Primitive数量
   * @returns {Number} Primitive数量
   */
  getPrimitivesCount() {
    return this.primitive.getCount();
  }

  /**
   * 显示或隐藏Primitive
   * @param {String|Primitive} idOrPrimitive - Primitive的ID或Primitive对象
   * @param {Boolean} show - 是否显示
   */
  setPrimitiveShow(idOrPrimitive, show) {
    this.primitive.setShow(idOrPrimitive, show);
  }

  /**
   * 批量添加Primitive
   * @param {Array} primitives - Primitive配置数组
   * @returns {Array} 添加的Primitive对象数组
   */
  addBatchPrimitives(primitives) {
    return this.primitive.addBatch(primitives);
  }

  /**
   * 销毁空间可视化系统
   */
  destroy() {
    if (this.modelManager) this.modelManager.destroy();
    if (this.cameraManager) this.cameraManager.destroy();
    if (this.appearanceManager) this.appearanceManager.destroy();
    if (this.provider) this.provider.destroy();
    if (this.dataSourse) this.dataSourse.destroy();
    
    this.modelManager = null;
    this.cameraManager = null;
    this.appearanceManager = null;
    this.provider = null;
    this.dataSourse = null;
    this.entity = null;
    this.primitive = null;
  }
}

// 使用案例示例
/*
// 1. 基础使用
const spatialVis = new SpatialVisualization('cesiumContainer');

// 2. 运行综合演示
spatialVis.runDemo();

// 3. 单独使用各功能模块
// 添加3D模型
spatialVis.addModel('car1', 
  {longitude: 112.98, latitude: 28.19, height: 0}, 
  '/models/car.glb',
  {scale: 1.0}
);

// 创建粒子效果
spatialVis.createRainEffect('rain', {
  particleCount: 2000,
  speed: 30,
  size: 1,
  color: Cesium.Color.BLUE.withAlpha(0.7)
});

// 添加实体
spatialVis.createPolygon('polygon1', [
  {longitude: 112.97, latitude: 28.18, height: 0},
  {longitude: 112.99, latitude: 28.18, height: 0},
  {longitude: 112.99, latitude: 28.20, height: 0},
  {longitude: 112.97, latitude: 28.20, height: 0}
], {
  material: Cesium.Color.RED.withAlpha(0.5)
});

// 相机控制
spatialVis.flyTo({
  destination: {longitude: 112.98, latitude: 28.19, height: 1000},
  duration: 3.0
});

// 组合使用：创建城市白膜模型并高亮
const buildings = [
  {
    id: 'building1',
    positions: [
      {longitude: 112.97, latitude: 28.18, height: 100},
      {longitude: 112.975, latitude: 28.18, height: 100},
      {longitude: 112.975, latitude: 28.185, height: 100},
      {longitude: 112.97, latitude: 28.185, height: 100}
    ]
  }
];

spatialVis.renderCityWhiteModel(buildings);
spatialVis.highlightBuilding('building1');

// 组合使用：创建模型动画和相机跟随
const model = spatialVis.addModel('satellite', 
  {longitude: 112.98, latitude: 28.19, height: 500}, 
  '/models/satellite.glb'
);

spatialVis.animateModel('satellite', {
  rotationAxis: 'z',
  rotationSpeed: 0.02
});

spatialVis.lockToEntity(model);
*/